package product

import (
	"github.com/gin-gonic/gin"
	"goskeleton/app/model"
	"goskeleton/app/utils/response"
	"strconv"
)

type ProductController struct {
}

// 获取商品列表
func (pc *ProductController) GetProductList(ctx *gin.Context) {
	// 创建 ProductModel 实例让数据库能进行连接
	productModel := model.CreateProductFactory("")

	// 获取 limit 参数，默认为 "10"（字符串）
	limitStr := ctx.DefaultQuery("limit", "10")
	lastIDStr := ctx.Query("last_id")
	productType := ctx.Query("product_type")

	// 将 limit 转换为 int
	limit, err := strconv.Atoi(limitStr)
	if err != nil {
		response.Fail(ctx, 301, "参数 limit 必须是整数", nil)
		return
	}

	// 将 lastID 转换为 int（如果 lastID 是可选的，可以处理空字符串）
	var lastID int
	if lastIDStr != "" {
		lastID, err = strconv.Atoi(lastIDStr)
		if err != nil {
			response.Fail(ctx, 301, "参数 lastID 必须是整数", nil)
			return
		}
	} else {
		// 如果 lastID 是空字符串，可以设置默认值（比如 0 或 -1）
		lastID = 0
	}

	// 调用 Service 获取商品列表
	products, err := productModel.GetProducts(limit, lastID, productType)
	if err != nil {
		response.Fail(ctx, 301, "获取商品列表失败: "+err.Error(), nil)
		return
	}

	// 返回成功响应
	response.Success(ctx, "成功", products)
}

// 获取商品类型
func (pc *ProductController) GetClassifyType(ctx *gin.Context) {
	// 创建 ProductModel 实例让数据库能进行连接
	productModel := model.CreateProductFactory("")
	types, err := productModel.GetClassifyType()
	if err != nil {
		response.Fail(ctx, 301, "获取商品类型失败: "+err.Error(), nil)
		return
	}
	response.Success(ctx, "成功", types)
	// 获取参数
}

// 发布商品
func (pc *ProductController) PublishProduct(ctx *gin.Context) {
	// 创建 ProductModel 实例让数据库能进行连接
	productModel := model.CreateProductFactory("")
	// 获取参数
	var product model.ProductModel
	err := ctx.ShouldBindJSON(&product)
	if err != nil {
		response.Fail(ctx, 301, "参数错误", nil)
		return
	}
	//在插入数据前将进行ai审核

	// 插入数据
	err = productModel.InsertProduct(product)
	if err != nil {
	}
	response.Success(ctx, "成功", nil)
}

// PublishProduct 发布商品，发布前进行文本审核
/*func (pc *ProductController) PublishProduct(ctx *gin.Context) {
	// 创建 ProductModel 实例让数据库能进行连接
	productModel := model.CreateProductFactory("")

	// 获取参数
	var product model.ProductModel
	err := ctx.ShouldBindJSON(&product)
	if err != nil {
		response.Fail(ctx, 301, "参数错误", nil)
		return
	}

	// 假设需要审核的字段是 Description 和 Title
	textsToCheck := map[string]string{
		"description": product.Description,
		"title":       product.Title,
	}

	var failedChecks []map[string]string

	for fieldName, text := range textsToCheck {
		if text == "" {
			continue // 跳过空字段
		}
		// 调用 AI 审核接口
		result, err := api.CheckText(text)
		if err != nil {
			response.Fail(ctx, 500, "文本审核服务异常: "+err.Error(), nil)
			return
		}
		if !result.Success {
			// 提取更详细的违规信息
			reason := result.Message
			if result.Data != nil {
				if data, ok := result.Data.(map[string]interface{}); ok {
					if suggestion, ok := data["suggestion"].(string); ok {
						reason = suggestion
					}
					if details, ok := data["details"].([]interface{}); ok && len(details) > 0 {
						reason = fmt.Sprintf("%s (违规类型: %v)", reason, details)
					}
				}
			}

			failedChecks = append(failedChecks, map[string]string{
				"field":   fieldName,
				"text":    text,
				"message": reason,
			})
		}
	}
	// 如果有审核失败项，返回失败信息
	if len(failedChecks) > 0 {
		response.Fail(ctx, 400, "部分文本未通过审核", failedChecks)
		return
	}
	// 插入数据
	err = productModel.InsertProduct(product)
	if err != nil {
		response.Fail(ctx, 301, "插入商品失败: "+err.Error(), nil)
		return
	}

	response.Success(ctx, "成功", nil)
}*/

// 获取用户发布的商品
func (pc *ProductController) GetUserProduct(ctx *gin.Context) {
	// 创建 ProductModel 实例让数据库能进行连接
	productModel := model.CreateProductFactory("")
	// 获取参数
	openId := ctx.Query("open_id")
	// 获取参数
	products, err := productModel.GetProductByOpenId(openId)
	if err != nil {
		return
	}
	response.Success(ctx, "成功", products)
}

func (pc *ProductController) UpdatePrice(context *gin.Context) {
	product_id := context.Query("product_id")
	new_price := context.Query("new_price")
	productModel := model.CreateProductFactory("")
	productModel.UpdatePrice(product_id, new_price)
	//也更改订单里的价格
	orderModel := model.CreateOrderFactory("")
	orderModel.UpdatePrice(product_id, new_price)

}

func (pc *ProductController) OffShelfProduct(context *gin.Context) {
	productId := context.Query("product_id")
	statusStr := context.Query("status")
	productModel := model.CreateProductFactory("")
	//根据productId去数据库中更新商品状态
	status, err := strconv.Atoi(statusStr)
	if err != nil {
		response.Fail(context, 301, "参数 status 必须是整数", nil)
		return
	}
	productModel.UpdateProductStatus(productId, status)

}

func (pc *ProductController) QueryProductStatus(context *gin.Context) {
	// 获取商品ID参数
	productId := context.Query("product_id")
	if productId == "" {
		response.Fail(context, 301, "参数 product_id 是必需的", nil)
		return
	}

	// 查询商品信息
	product := model.CreateProductFactory("")
	productInfo := product.QueryProductStatus(productId)
	if productInfo == nil {
		response.Fail(context, 301, "商品不存在", nil)
		return
	}
	response.Success(context, "成功", productInfo)

}

func (pc *ProductController) SearchProduct(context *gin.Context) {
	//去搜索商品
	productModel := model.CreateProductFactory("")
	products := productModel.SearchProduct(context.Query("keyword"))
	response.Success(context, "成功", products)

}
